/**
 * Created by Chen zeming on 2014/11/10.
 */
/**
 * 截图插件
 */
define('jcrop/0.9.12/jquery.Jcrop',
	[
        '$',
        'jcrop/0.9.12/jquery.color',
        'jcrop/0.9.12/css/jquery.Jcrop.min.css'
    ], 
    function (require, exports, module) {
		/**
		 * jquery.Jcrop.js v0.9.12
		 * jQuery Image Cropping Plugin - released under MIT License 
		 * Author: Kelly Hallman <khallman@gmail.com>
		 * http://github.com/tapmodo/Jcrop
		 * Copyright (c) 2008-2013 Tapmodo Interactive LLC {{{
		 *
		 * Permission is hereby granted, free of charge, to any person
		 * obtaining a copy of this software and associated documentation
		 * files (the "Software"), to deal in the Software without
		 * restriction, including without limitation the rights to use,
		 * copy, modify, merge, publish, distribute, sublicense, and/or sell
		 * copies of the Software, and to permit persons to whom the
		 * Software is furnished to do so, subject to the following
		 * conditions:
		 *
		 * The above copyright notice and this permission notice shall be
		 * included in all copies or substantial portions of the Software.
		 *
		 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
		 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
		 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
		 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
		 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
		 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
		 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
		 * OTHER DEALINGS IN THE SOFTWARE.
		 *
		 * }}}
		 */
		
		(function ($) {
		
		  $.Jcrop = function (obj, opt) {
		    var options = $.extend({}, $.Jcrop.defaults),
		        docOffset,
		        _ua = navigator.userAgent.toLowerCase(),
		        is_msie = /msie/.test(_ua),
		        ie6mode = /msie [1-6]\./.test(_ua);
		
		    // Internal Methods {{{
		    function px(n) {
		      return Math.round(n) + 'px';
		    }
		    function cssClass(cl) {
		      return options.baseClass + '-' + cl;
		    }
		    function supportsColorFade() {
		      return $.fx.step.hasOwnProperty('backgroundColor');
		    }
		    function getPos(obj) //{{{
		    {
		      var pos = $(obj).offset();
		      return [pos.left, pos.top];
		    }
		    //}}}
		    function mouseAbs(e) //{{{
		    {
		      return [(e.pageX - docOffset[0]), (e.pageY - docOffset[1])];
		    }
		    //}}}
		    function setOptions(opt) //{{{
		    {
		      if (typeof(opt) !== 'object') opt = {};
		      options = $.extend(options, opt);
		
		      $.each(['onChange','onSelect','onRelease','onDblClick'],function(i,e) {
		        if (typeof(options[e]) !== 'function') options[e] = function () {};
		      });
		    }
		    //}}}
		    function startDragMode(mode, pos, touch) //{{{
		    {
		      docOffset = getPos($img);
		      Tracker.setCursor(mode === 'move' ? mode : mode + '-resize');
		
		      if (mode === 'move') {
		        return Tracker.activateHandlers(createMover(pos), doneSelect, touch);
		      }
		
		      var fc = Coords.getFixed();
		      var opp = oppLockCorner(mode);
		      var opc = Coords.getCorner(oppLockCorner(opp));
		
		      Coords.setPressed(Coords.getCorner(opp));
		      Coords.setCurrent(opc);
		
		      Tracker.activateHandlers(dragmodeHandler(mode, fc), doneSelect, touch);
		    }
		    //}}}
		    function dragmodeHandler(mode, f) //{{{
		    {
		      return function (pos) {
		        if (!options.aspectRatio) {
		          switch (mode) {
		          case 'e':
		            pos[1] = f.y2;
		            break;
		          case 'w':
		            pos[1] = f.y2;
		            break;
		          case 'n':
		            pos[0] = f.x2;
		            break;
		          case 's':
		            pos[0] = f.x2;
		            break;
		          }
		        } else {
		          switch (mode) {
		          case 'e':
		            pos[1] = f.y + 1;
		            break;
		          case 'w':
		            pos[1] = f.y + 1;
		            break;
		          case 'n':
		            pos[0] = f.x + 1;
		            break;
		          case 's':
		            pos[0] = f.x + 1;
		            break;
		          }
		        }
		        Coords.setCurrent(pos);
		        Selection.update();
		      };
		    }
		    //}}}
		    function createMover(pos) //{{{
		    {
		      var lloc = pos;
		      KeyManager.watchKeys();
		
		      return function (pos) {
		        Coords.moveOffset([pos[0] - lloc[0], pos[1] - lloc[1]]);
		        lloc = pos;
		
		        Selection.update();
		      };
		    }
		    //}}}
		    function oppLockCorner(ord) //{{{
		    {
		      switch (ord) {
		      case 'n':
		        return 'sw';
		      case 's':
		        return 'nw';
		      case 'e':
		        return 'nw';
		      case 'w':
		        return 'ne';
		      case 'ne':
		        return 'sw';
		      case 'nw':
		        return 'se';
		      case 'se':
		        return 'nw';
		      case 'sw':
		        return 'ne';
		      }
		    }
		    //}}}
		    function createDragger(ord) //{{{
		    {
		      return function (e) {
		        if (options.disabled) {
		          return false;
		        }
		        if ((ord === 'move') && !options.allowMove) {
		          return false;
		        }
		        
		        // Fix position of crop area when dragged the very first time.
		        // Necessary when crop image is in a hidden element when page is loaded.
		        docOffset = getPos($img);
		
		        btndown = true;
		        startDragMode(ord, mouseAbs(e));
		        e.stopPropagation();
		        e.preventDefault();
		        return false;
		      };
		    }
		    //}}}
		    function presize($obj, w, h) //{{{
		    {
		      var nw = $obj.width(),
		          nh = $obj.height();
		      if ((nw > w) && w > 0) {
		        nw = w;
		        nh = (w / $obj.width()) * $obj.height();
		      }
		      if ((nh > h) && h > 0) {
		        nh = h;
		        nw = (h / $obj.height()) * $obj.width();
		      }
		      xscale = $obj.width() / nw;
		      yscale = $obj.height() / nh;
		      $obj.width(nw).height(nh);
		    }
		    //}}}
		    function unscale(c) //{{{
		    {
		      return {
		        x: c.x * xscale,
		        y: c.y * yscale,
		        x2: c.x2 * xscale,
		        y2: c.y2 * yscale,
		        w: c.w * xscale,
		        h: c.h * yscale
		      };
		    }
		    //}}}
		    function doneSelect(pos) //{{{
		    {
		      var c = Coords.getFixed();
		      if ((c.w > options.minSelect[0]) && (c.h > options.minSelect[1])) {
		        Selection.enableHandles();
		        Selection.done();
		      } else {
		        Selection.release();
		      }
		      Tracker.setCursor(options.allowSelect ? 'crosshair' : 'default');
		    }
		    //}}}
		    function newSelection(e) //{{{
		    {
		      if (options.disabled) {
		        return false;
		      }
		      if (!options.allowSelect) {
		        return false;
		      }
		      btndown = true;
		      docOffset = getPos($img);
		      Selection.disableHandles();
		      Tracker.setCursor('crosshair');
		      var pos = mouseAbs(e);
		      Coords.setPressed(pos);
		      Selection.update();
		      Tracker.activateHandlers(selectDrag, doneSelect, e.type.substring(0,5)==='touch');
		      KeyManager.watchKeys();
		
		      e.stopPropagation();
		      e.preventDefault();
		      return false;
		    }
		    //}}}
		    function selectDrag(pos) //{{{
		    {
		      Coords.setCurrent(pos);
		      Selection.update();
		    }
		    //}}}
		    function newTracker() //{{{
		    {
		      var trk = $('<div></div>').addClass(cssClass('tracker'));
		      if (is_msie) {
		        trk.css({
		          opacity: 0,
		          backgroundColor: 'white'
		        });
		      }
		      return trk;
		    }
		    //}}}
		
		    // }}}
		    // Initialization {{{
		    // Sanitize some options {{{
		    if (typeof(obj) !== 'object') {
		      obj = $(obj)[0];
		    }
		    if (typeof(opt) !== 'object') {
		      opt = {};
		    }
		    // }}}
		    setOptions(opt);
		    // Initialize some jQuery objects {{{
		    // The values are SET on the image(s) for the interface
		    // If the original image has any of these set, they will be reset
		    // However, if you destroy() the Jcrop instance the original image's
		    // character in the DOM will be as you left it.
		    var img_css = {
		      border: 'none',
		      visibility: 'visible',
		      margin: 0,
		      padding: 0,
		      position: 'absolute',
		      top: 0,
		      left: 0
		    };
		
		    var $origimg = $(obj),
		      img_mode = true;
		
		    if (obj.tagName == 'IMG') {
		      // Fix size of crop image.
		      // Necessary when crop image is within a hidden element when page is loaded.
		      if ($origimg[0].width != 0 && $origimg[0].height != 0) {
		        // Obtain dimensions from contained img element.
		        $origimg.width($origimg[0].width);
		        $origimg.height($origimg[0].height);
		      } else {
		        // Obtain dimensions from temporary image in case the original is not loaded yet (e.g. IE 7.0). 
		        var tempImage = new Image();
		        tempImage.src = $origimg[0].src;
		        $origimg.width(tempImage.width);
		        $origimg.height(tempImage.height);
		      } 
		
		      var $img = $origimg.clone().removeAttr('id').css(img_css).show();
		
		      $img.width($origimg.width());
		      $img.height($origimg.height());
		      $origimg.after($img).hide();
		
		    } else {
		      $img = $origimg.css(img_css).show();
		      img_mode = false;
		      if (options.shade === null) { options.shade = true; }
		    }
		
		    presize($img, options.boxWidth, options.boxHeight);
		
		    var boundx = $img.width(),
		        boundy = $img.height(),
		        
		        
		        $div = $('<div />').width(boundx).height(boundy).addClass(cssClass('holder')).css({
		        position: 'relative',
		        backgroundColor: options.bgColor
		      }).insertAfter($origimg).append($img);
		
		    if (options.addClass) {
		      $div.addClass(options.addClass);
		    }
		
		    var $img2 = $('<div />'),
		
		        $img_holder = $('<div />') 
		        .width('100%').height('100%').css({
		          zIndex: 310,
		          position: 'absolute',
		          overflow: 'hidden'
		        }),
		
		        $hdl_holder = $('<div />') 
		        .width('100%').height('100%').css('zIndex', 320), 
		
		        $sel = $('<div />') 
		        .css({
		          position: 'absolute',
		          zIndex: 600
		        }).dblclick(function(){
		          var c = Coords.getFixed();
		          options.onDblClick.call(api,c);
		        }).insertBefore($img).append($img_holder, $hdl_holder); 
		
		    if (img_mode) {
		
		      $img2 = $('<img />')
		          .attr('src', $img.attr('src')).css(img_css).width(boundx).height(boundy),
		
		      $img_holder.append($img2);
		
		    }
		
		    if (ie6mode) {
		      $sel.css({
		        overflowY: 'hidden'
		      });
		    }
		
		    var bound = options.boundary;
		    var $trk = newTracker().width(boundx + (bound * 2)).height(boundy + (bound * 2)).css({
		      position: 'absolute',
		      top: px(-bound),
		      left: px(-bound),
		      zIndex: 290
		    }).mousedown(newSelection);
		
		    /* }}} */
		    // Set more variables {{{
		    var bgcolor = options.bgColor,
		        bgopacity = options.bgOpacity,
		        xlimit, ylimit, xmin, ymin, xscale, yscale, enabled = true,
		        btndown, animating, shift_down;
		
		    docOffset = getPos($img);
		    // }}}
		    // }}}
		    // Internal Modules {{{
		    // Touch Module {{{ 
		    var Touch = (function () {
		      // Touch support detection function adapted (under MIT License)
		      // from code by Jeffrey Sambells - http://github.com/iamamused/
		      function hasTouchSupport() {
		        var support = {}, events = ['touchstart', 'touchmove', 'touchend'],
		            el = document.createElement('div'), i;
		
		        try {
		          for(i=0; i<events.length; i++) {
		            var eventName = events[i];
		            eventName = 'on' + eventName;
		            var isSupported = (eventName in el);
		            if (!isSupported) {
		              el.setAttribute(eventName, 'return;');
		              isSupported = typeof el[eventName] == 'function';
		            }
		            support[events[i]] = isSupported;
		          }
		          return support.touchstart && support.touchend && support.touchmove;
		        }
		        catch(err) {
		          return false;
		        }
		      }
		
		      function detectSupport() {
		        if ((options.touchSupport === true) || (options.touchSupport === false)) return options.touchSupport;
		          else return hasTouchSupport();
		      }
		      return {
		        createDragger: function (ord) {
		          return function (e) {
		            if (options.disabled) {
		              return false;
		            }
		            if ((ord === 'move') && !options.allowMove) {
		              return false;
		            }
		            docOffset = getPos($img);
		            btndown = true;
		            startDragMode(ord, mouseAbs(Touch.cfilter(e)), true);
		            e.stopPropagation();
		            e.preventDefault();
		            return false;
		          };
		        },
		        newSelection: function (e) {
		          return newSelection(Touch.cfilter(e));
		        },
		        cfilter: function (e){
		          e.pageX = e.originalEvent.changedTouches[0].pageX;
		          e.pageY = e.originalEvent.changedTouches[0].pageY;
		          return e;
		        },
		        isSupported: hasTouchSupport,
		        support: detectSupport()
		      };
		    }());
		    // }}}
		    // Coords Module {{{
		    var Coords = (function () {
		      var x1 = 0,
		          y1 = 0,
		          x2 = 0,
		          y2 = 0,
		          ox, oy;
		
		      function setPressed(pos) //{{{
		      {
		        pos = rebound(pos);
		        x2 = x1 = pos[0];
		        y2 = y1 = pos[1];
		      }
		      //}}}
		      function setCurrent(pos) //{{{
		      {
		        pos = rebound(pos);
		        ox = pos[0] - x2;
		        oy = pos[1] - y2;
		        x2 = pos[0];
		        y2 = pos[1];
		      }
		      //}}}
		      function getOffset() //{{{
		      {
		        return [ox, oy];
		      }
		      //}}}
		      function moveOffset(offset) //{{{
		      {
		        var ox = offset[0],
		            oy = offset[1];
		
		        if (0 > x1 + ox) {
		          ox -= ox + x1;
		        }
		        if (0 > y1 + oy) {
		          oy -= oy + y1;
		        }
		
		        if (boundy < y2 + oy) {
		          oy += boundy - (y2 + oy);
		        }
		        if (boundx < x2 + ox) {
		          ox += boundx - (x2 + ox);
		        }
		
		        x1 += ox;
		        x2 += ox;
		        y1 += oy;
		        y2 += oy;
		      }
		      //}}}
		      function getCorner(ord) //{{{
		      {
		        var c = getFixed();
		        switch (ord) {
		        case 'ne':
		          return [c.x2, c.y];
		        case 'nw':
		          return [c.x, c.y];
		        case 'se':
		          return [c.x2, c.y2];
		        case 'sw':
		          return [c.x, c.y2];
		        }
		      }
		      //}}}
		      function getFixed() //{{{
		      {
		        if (!options.aspectRatio) {
		          return getRect();
		        }
		        // This function could use some optimization I think...
		        var aspect = options.aspectRatio,
		            min_x = options.minSize[0] / xscale,
		            
		            
		            //min_y = options.minSize[1]/yscale,
		            max_x = options.maxSize[0] / xscale,
		            max_y = options.maxSize[1] / yscale,
		            rw = x2 - x1,
		            rh = y2 - y1,
		            rwa = Math.abs(rw),
		            rha = Math.abs(rh),
		            real_ratio = rwa / rha,
		            xx, yy, w, h;
		
		        if (max_x === 0) {
		          max_x = boundx * 10;
		        }
		        if (max_y === 0) {
		          max_y = boundy * 10;
		        }
		        if (real_ratio < aspect) {
		          yy = y2;
		          w = rha * aspect;
		          xx = rw < 0 ? x1 - w : w + x1;
		
		          if (xx < 0) {
		            xx = 0;
		            h = Math.abs((xx - x1) / aspect);
		            yy = rh < 0 ? y1 - h : h + y1;
		          } else if (xx > boundx) {
		            xx = boundx;
		            h = Math.abs((xx - x1) / aspect);
		            yy = rh < 0 ? y1 - h : h + y1;
		          }
		        } else {
		          xx = x2;
		          h = rwa / aspect;
		          yy = rh < 0 ? y1 - h : y1 + h;
		          if (yy < 0) {
		            yy = 0;
		            w = Math.abs((yy - y1) * aspect);
		            xx = rw < 0 ? x1 - w : w + x1;
		          } else if (yy > boundy) {
		            yy = boundy;
		            w = Math.abs(yy - y1) * aspect;
		            xx = rw < 0 ? x1 - w : w + x1;
		          }
		        }
		
		        // Magic %-)
		        if (xx > x1) { // right side
		          if (xx - x1 < min_x) {
		            xx = x1 + min_x;
		          } else if (xx - x1 > max_x) {
		            xx = x1 + max_x;
		          }
		          if (yy > y1) {
		            yy = y1 + (xx - x1) / aspect;
		          } else {
		            yy = y1 - (xx - x1) / aspect;
		          }
		        } else if (xx < x1) { // left side
		          if (x1 - xx < min_x) {
		            xx = x1 - min_x;
		          } else if (x1 - xx > max_x) {
		            xx = x1 - max_x;
		          }
		          if (yy > y1) {
		            yy = y1 + (x1 - xx) / aspect;
		          } else {
		            yy = y1 - (x1 - xx) / aspect;
		          }
		        }
		
		        if (xx < 0) {
		          x1 -= xx;
		          xx = 0;
		        } else if (xx > boundx) {
		          x1 -= xx - boundx;
		          xx = boundx;
		        }
		
		        if (yy < 0) {
		          y1 -= yy;
		          yy = 0;
		        } else if (yy > boundy) {
		          y1 -= yy - boundy;
		          yy = boundy;
		        }
		
		        return makeObj(flipCoords(x1, y1, xx, yy));
		      }
		      //}}}
		      function rebound(p) //{{{
		      {
		        if (p[0] < 0) p[0] = 0;
		        if (p[1] < 0) p[1] = 0;
		
		        if (p[0] > boundx) p[0] = boundx;
		        if (p[1] > boundy) p[1] = boundy;
		
		        return [Math.round(p[0]), Math.round(p[1])];
		      }
		      //}}}
		      function flipCoords(x1, y1, x2, y2) //{{{
		      {
		        var xa = x1,
		            xb = x2,
		            ya = y1,
		            yb = y2;
		        if (x2 < x1) {
		          xa = x2;
		          xb = x1;
		        }
		        if (y2 < y1) {
		          ya = y2;
		          yb = y1;
		        }
		        return [xa, ya, xb, yb];
		      }
		      //}}}
		      function getRect() //{{{
		      {
		        var xsize = x2 - x1,
		            ysize = y2 - y1,
		            delta;
		
		        if (xlimit && (Math.abs(xsize) > xlimit)) {
		          x2 = (xsize > 0) ? (x1 + xlimit) : (x1 - xlimit);
		        }
		        if (ylimit && (Math.abs(ysize) > ylimit)) {
		          y2 = (ysize > 0) ? (y1 + ylimit) : (y1 - ylimit);
		        }
		
		        if (ymin / yscale && (Math.abs(ysize) < ymin / yscale)) {
		          y2 = (ysize > 0) ? (y1 + ymin / yscale) : (y1 - ymin / yscale);
		        }
		        if (xmin / xscale && (Math.abs(xsize) < xmin / xscale)) {
		          x2 = (xsize > 0) ? (x1 + xmin / xscale) : (x1 - xmin / xscale);
		        }
		
		        if (x1 < 0) {
		          x2 -= x1;
		          x1 -= x1;
		        }
		        if (y1 < 0) {
		          y2 -= y1;
		          y1 -= y1;
		        }
		        if (x2 < 0) {
		          x1 -= x2;
		          x2 -= x2;
		        }
		        if (y2 < 0) {
		          y1 -= y2;
		          y2 -= y2;
		        }
		        if (x2 > boundx) {
		          delta = x2 - boundx;
		          x1 -= delta;
		          x2 -= delta;
		        }
		        if (y2 > boundy) {
		          delta = y2 - boundy;
		          y1 -= delta;
		          y2 -= delta;
		        }
		        if (x1 > boundx) {
		          delta = x1 - boundy;
		          y2 -= delta;
		          y1 -= delta;
		        }
		        if (y1 > boundy) {
		          delta = y1 - boundy;
		          y2 -= delta;
		          y1 -= delta;
		        }
		
		        return makeObj(flipCoords(x1, y1, x2, y2));
		      }
		      //}}}
		      function makeObj(a) //{{{
		      {
		        return {
		          x: a[0],
		          y: a[1],
		          x2: a[2],
		          y2: a[3],
		          w: a[2] - a[0],
		          h: a[3] - a[1]
		        };
		      }
		      //}}}
		
		      return {
		        flipCoords: flipCoords,
		        setPressed: setPressed,
		        setCurrent: setCurrent,
		        getOffset: getOffset,
		        moveOffset: moveOffset,
		        getCorner: getCorner,
		        getFixed: getFixed
		      };
		    }());
		
		    //}}}
		    // Shade Module {{{
		    var Shade = (function() {
		      var enabled = false,
		          holder = $('<div />').css({
		            position: 'absolute',
		            zIndex: 240,
		            opacity: 0
		          }),
		          shades = {
		            top: createShade(),
		            left: createShade().height(boundy),
		            right: createShade().height(boundy),
		            bottom: createShade()
		          };
		
		      function resizeShades(w,h) {
		        shades.left.css({ height: px(h) });
		        shades.right.css({ height: px(h) });
		      }
		      function updateAuto()
		      {
		        return updateShade(Coords.getFixed());
		      }
		      function updateShade(c)
		      {
		        shades.top.css({
		          left: px(c.x),
		          width: px(c.w),
		          height: px(c.y)
		        });
		        shades.bottom.css({
		          top: px(c.y2),
		          left: px(c.x),
		          width: px(c.w),
		          height: px(boundy-c.y2)
		        });
		        shades.right.css({
		          left: px(c.x2),
		          width: px(boundx-c.x2)
		        });
		        shades.left.css({
		          width: px(c.x)
		        });
		      }
		      function createShade() {
		        return $('<div />').css({
		          position: 'absolute',
		          backgroundColor: options.shadeColor||options.bgColor
		        }).appendTo(holder);
		      }
		      function enableShade() {
		        if (!enabled) {
		          enabled = true;
		          holder.insertBefore($img);
		          updateAuto();
		          Selection.setBgOpacity(1,0,1);
		          $img2.hide();
		
		          setBgColor(options.shadeColor||options.bgColor,1);
		          if (Selection.isAwake())
		          {
		            setOpacity(options.bgOpacity,1);
		          }
		            else setOpacity(1,1);
		        }
		      }
		      function setBgColor(color,now) {
		        colorChangeMacro(getShades(),color,now);
		      }
		      function disableShade() {
		        if (enabled) {
		          holder.remove();
		          $img2.show();
		          enabled = false;
		          if (Selection.isAwake()) {
		            Selection.setBgOpacity(options.bgOpacity,1,1);
		          } else {
		            Selection.setBgOpacity(1,1,1);
		            Selection.disableHandles();
		          }
		          colorChangeMacro($div,0,1);
		        }
		      }
		      function setOpacity(opacity,now) {
		        if (enabled) {
		          if (options.bgFade && !now) {
		            holder.animate({
		              opacity: 1-opacity
		            },{
		              queue: false,
		              duration: options.fadeTime
		            });
		          }
		          else holder.css({opacity:1-opacity});
		        }
		      }
		      function refreshAll() {
		        options.shade ? enableShade() : disableShade();
		        if (Selection.isAwake()) setOpacity(options.bgOpacity);
		      }
		      function getShades() {
		        return holder.children();
		      }
		
		      return {
		        update: updateAuto,
		        updateRaw: updateShade,
		        getShades: getShades,
		        setBgColor: setBgColor,
		        enable: enableShade,
		        disable: disableShade,
		        resize: resizeShades,
		        refresh: refreshAll,
		        opacity: setOpacity
		      };
		    }());
		    // }}}
		    // Selection Module {{{
		    var Selection = (function () {
		      var awake,
		          hdep = 370,
		          borders = {},
		          handle = {},
		          dragbar = {},
		          seehandles = false;
		
		      // Private Methods
		      function insertBorder(type) //{{{
		      {
		        var jq = $('<div />').css({
		          position: 'absolute',
		          opacity: options.borderOpacity
		        }).addClass(cssClass(type));
		        $img_holder.append(jq);
		        return jq;
		      }
		      //}}}
		      function dragDiv(ord, zi) //{{{
		      {
		        var jq = $('<div />').mousedown(createDragger(ord)).css({
		          cursor: ord + '-resize',
		          position: 'absolute',
		          zIndex: zi
		        }).addClass('ord-'+ord);
		
		        if (Touch.support) {
		          jq.bind('touchstart.jcrop', Touch.createDragger(ord));
		        }
		
		        $hdl_holder.append(jq);
		        return jq;
		      }
		      //}}}
		      function insertHandle(ord) //{{{
		      {
		        var hs = options.handleSize,
		
		          div = dragDiv(ord, hdep++).css({
		            opacity: options.handleOpacity
		          }).addClass(cssClass('handle'));
		
		        if (hs) { div.width(hs).height(hs); }
		
		        return div;
		      }
		      //}}}
		      function insertDragbar(ord) //{{{
		      {
		        return dragDiv(ord, hdep++).addClass('jcrop-dragbar');
		      }
		      //}}}
		      function createDragbars(li) //{{{
		      {
		        var i;
		        for (i = 0; i < li.length; i++) {
		          dragbar[li[i]] = insertDragbar(li[i]);
		        }
		      }
		      //}}}
		      function createBorders(li) //{{{
		      {
		        var cl,i;
		        for (i = 0; i < li.length; i++) {
		          switch(li[i]){
		            case'n': cl='hline'; break;
		            case's': cl='hline bottom'; break;
		            case'e': cl='vline right'; break;
		            case'w': cl='vline'; break;
		          }
		          borders[li[i]] = insertBorder(cl);
		        }
		      }
		      //}}}
		      function createHandles(li) //{{{
		      {
		        var i;
		        for (i = 0; i < li.length; i++) {
		          handle[li[i]] = insertHandle(li[i]);
		        }
		      }
		      //}}}
		      function moveto(x, y) //{{{
		      {
		        if (!options.shade) {
		          $img2.css({
		            top: px(-y),
		            left: px(-x)
		          });
		        }
		        $sel.css({
		          top: px(y),
		          left: px(x)
		        });
		      }
		      //}}}
		      function resize(w, h) //{{{
		      {
		        $sel.width(Math.round(w)).height(Math.round(h));
		      }
		      //}}}
		      function refresh() //{{{
		      {
		        var c = Coords.getFixed();
		
		        Coords.setPressed([c.x, c.y]);
		        Coords.setCurrent([c.x2, c.y2]);
		
		        updateVisible();
		      }
		      //}}}
		
		      // Internal Methods
		      function updateVisible(select) //{{{
		      {
		        if (awake) {
		          return update(select);
		        }
		      }
		      //}}}
		      function update(select) //{{{
		      {
		        var c = Coords.getFixed();
		
		        resize(c.w, c.h);
		        moveto(c.x, c.y);
		        if (options.shade) Shade.updateRaw(c);
		
		        awake || show();
		
		        if (select) {
		          options.onSelect.call(api, unscale(c));
		        } else {
		          options.onChange.call(api, unscale(c));
		        }
		      }
		      //}}}
		      function setBgOpacity(opacity,force,now) //{{{
		      {
		        if (!awake && !force) return;
		        if (options.bgFade && !now) {
		          $img.animate({
		            opacity: opacity
		          },{
		            queue: false,
		            duration: options.fadeTime
		          });
		        } else {
		          $img.css('opacity', opacity);
		        }
		      }
		      //}}}
		      function show() //{{{
		      {
		        $sel.show();
		
		        if (options.shade) Shade.opacity(bgopacity);
		          else setBgOpacity(bgopacity,true);
		
		        awake = true;
		      }
		      //}}}
		      function release() //{{{
		      {
		        disableHandles();
		        $sel.hide();
		
		        if (options.shade) Shade.opacity(1);
		          else setBgOpacity(1);
		
		        awake = false;
		        options.onRelease.call(api);
		      }
		      //}}}
		      function showHandles() //{{{
		      {
		        if (seehandles) {
		          $hdl_holder.show();
		        }
		      }
		      //}}}
		      function enableHandles() //{{{
		      {
		        seehandles = true;
		        if (options.allowResize) {
		          $hdl_holder.show();
		          return true;
		        }
		      }
		      //}}}
		      function disableHandles() //{{{
		      {
		        seehandles = false;
		        $hdl_holder.hide();
		      } 
		      //}}}
		      function animMode(v) //{{{
		      {
		        if (v) {
		          animating = true;
		          disableHandles();
		        } else {
		          animating = false;
		          enableHandles();
		        }
		      } 
		      //}}}
		      function done() //{{{
		      {
		        animMode(false);
		        refresh();
		      } 
		      //}}}
		      // Insert draggable elements {{{
		      // Insert border divs for outline
		
		      if (options.dragEdges && $.isArray(options.createDragbars))
		        createDragbars(options.createDragbars);
		
		      if ($.isArray(options.createHandles))
		        createHandles(options.createHandles);
		
		      if (options.drawBorders && $.isArray(options.createBorders))
		        createBorders(options.createBorders);
		
		      //}}}
		
		      // This is a hack for iOS5 to support drag/move touch functionality
		      $(document).bind('touchstart.jcrop-ios',function(e) {
		        if ($(e.currentTarget).hasClass('jcrop-tracker')) e.stopPropagation();
		      });
		
		      var $track = newTracker().mousedown(createDragger('move')).css({
		        cursor: 'move',
		        position: 'absolute',
		        zIndex: 360
		      });
		
		      if (Touch.support) {
		        $track.bind('touchstart.jcrop', Touch.createDragger('move'));
		      }
		
		      $img_holder.append($track);
		      disableHandles();
		
		      return {
		        updateVisible: updateVisible,
		        update: update,
		        release: release,
		        refresh: refresh,
		        isAwake: function () {
		          return awake;
		        },
		        setCursor: function (cursor) {
		          $track.css('cursor', cursor);
		        },
		        enableHandles: enableHandles,
		        enableOnly: function () {
		          seehandles = true;
		        },
		        showHandles: showHandles,
		        disableHandles: disableHandles,
		        animMode: animMode,
		        setBgOpacity: setBgOpacity,
		        done: done
		      };
		    }());
		    
		    //}}}
		    // Tracker Module {{{
		    var Tracker = (function () {
		      var onMove = function () {},
		          onDone = function () {},
		          trackDoc = options.trackDocument;
		
		      function toFront(touch) //{{{
		      {
		        $trk.css({
		          zIndex: 450
		        });
		
		        if (touch)
		          $(document)
		            .bind('touchmove.jcrop', trackTouchMove)
		            .bind('touchend.jcrop', trackTouchEnd);
		
		        else if (trackDoc)
		          $(document)
		            .bind('mousemove.jcrop',trackMove)
		            .bind('mouseup.jcrop',trackUp);
		      } 
		      //}}}
		      function toBack() //{{{
		      {
		        $trk.css({
		          zIndex: 290
		        });
		        $(document).unbind('.jcrop');
		      } 
		      //}}}
		      function trackMove(e) //{{{
		      {
		        onMove(mouseAbs(e));
		        return false;
		      } 
		      //}}}
		      function trackUp(e) //{{{
		      {
		        e.preventDefault();
		        e.stopPropagation();
		
		        if (btndown) {
		          btndown = false;
		
		          onDone(mouseAbs(e));
		
		          if (Selection.isAwake()) {
		            options.onSelect.call(api, unscale(Coords.getFixed()));
		          }
		
		          toBack();
		          onMove = function () {};
		          onDone = function () {};
		        }
		
		        return false;
		      }
		      //}}}
		      function activateHandlers(move, done, touch) //{{{
		      {
		        btndown = true;
		        onMove = move;
		        onDone = done;
		        toFront(touch);
		        return false;
		      }
		      //}}}
		      function trackTouchMove(e) //{{{
		      {
		        onMove(mouseAbs(Touch.cfilter(e)));
		        return false;
		      }
		      //}}}
		      function trackTouchEnd(e) //{{{
		      {
		        return trackUp(Touch.cfilter(e));
		      }
		      //}}}
		      function setCursor(t) //{{{
		      {
		        $trk.css('cursor', t);
		      }
		      //}}}
		
		      if (!trackDoc) {
		        $trk.mousemove(trackMove).mouseup(trackUp).mouseout(trackUp);
		      }
		
		      $img.before($trk);
		      return {
		        activateHandlers: activateHandlers,
		        setCursor: setCursor
		      };
		    }());
		    //}}}
		    // KeyManager Module {{{
		    var KeyManager = (function () {
		      var $keymgr = $('<input type="radio" />').css({
		        position: 'fixed',
		        left: '-120px',
		        width: '12px'
		      }).addClass('jcrop-keymgr'),
		
		        $keywrap = $('<div />').css({
		          position: 'absolute',
		          overflow: 'hidden'
		        }).append($keymgr);
		
		      function watchKeys() //{{{
		      {
		        if (options.keySupport) {
		          $keymgr.show();
		          $keymgr.focus();
		        }
		      }
		      //}}}
		      function onBlur(e) //{{{
		      {
		        $keymgr.hide();
		      }
		      //}}}
		      function doNudge(e, x, y) //{{{
		      {
		        if (options.allowMove) {
		          Coords.moveOffset([x, y]);
		          Selection.updateVisible(true);
		        }
		        e.preventDefault();
		        e.stopPropagation();
		      }
		      //}}}
		      function parseKey(e) //{{{
		      {
		        if (e.ctrlKey || e.metaKey) {
		          return true;
		        }
		        shift_down = e.shiftKey ? true : false;
		        var nudge = shift_down ? 10 : 1;
		
		        switch (e.keyCode) {
		        case 37:
		          doNudge(e, -nudge, 0);
		          break;
		        case 39:
		          doNudge(e, nudge, 0);
		          break;
		        case 38:
		          doNudge(e, 0, -nudge);
		          break;
		        case 40:
		          doNudge(e, 0, nudge);
		          break;
		        case 27:
		          if (options.allowSelect) Selection.release();
		          break;
		        case 9:
		          return true;
		        }
		
		        return false;
		      }
		      //}}}
		
		      if (options.keySupport) {
		        $keymgr.keydown(parseKey).blur(onBlur);
		        if (ie6mode || !options.fixedSupport) {
		          $keymgr.css({
		            position: 'absolute',
		            left: '-20px'
		          });
		          $keywrap.append($keymgr).insertBefore($img);
		        } else {
		          $keymgr.insertBefore($img);
		        }
		      }
		
		
		      return {
		        watchKeys: watchKeys
		      };
		    }());
		    //}}}
		    // }}}
		    // API methods {{{
		    function setClass(cname) //{{{
		    {
		      $div.removeClass().addClass(cssClass('holder')).addClass(cname);
		    }
		    //}}}
		    function animateTo(a, callback) //{{{
		    {
		      var x1 = a[0] / xscale,
		          y1 = a[1] / yscale,
		          x2 = a[2] / xscale,
		          y2 = a[3] / yscale;
		
		      if (animating) {
		        return;
		      }
		
		      var animto = Coords.flipCoords(x1, y1, x2, y2),
		          c = Coords.getFixed(),
		          initcr = [c.x, c.y, c.x2, c.y2],
		          animat = initcr,
		          interv = options.animationDelay,
		          ix1 = animto[0] - initcr[0],
		          iy1 = animto[1] - initcr[1],
		          ix2 = animto[2] - initcr[2],
		          iy2 = animto[3] - initcr[3],
		          pcent = 0,
		          velocity = options.swingSpeed;
		
		      x1 = animat[0];
		      y1 = animat[1];
		      x2 = animat[2];
		      y2 = animat[3];
		
		      Selection.animMode(true);
		      var anim_timer;
		
		      function queueAnimator() {
		        window.setTimeout(animator, interv);
		      }
		      var animator = (function () {
		        return function () {
		          pcent += (100 - pcent) / velocity;
		
		          animat[0] = Math.round(x1 + ((pcent / 100) * ix1));
		          animat[1] = Math.round(y1 + ((pcent / 100) * iy1));
		          animat[2] = Math.round(x2 + ((pcent / 100) * ix2));
		          animat[3] = Math.round(y2 + ((pcent / 100) * iy2));
		
		          if (pcent >= 99.8) {
		            pcent = 100;
		          }
		          if (pcent < 100) {
		            setSelectRaw(animat);
		            queueAnimator();
		          } else {
		            Selection.done();
		            Selection.animMode(false);
		            if (typeof(callback) === 'function') {
		              callback.call(api);
		            }
		          }
		        };
		      }());
		      queueAnimator();
		    }
		    //}}}
		    function setSelect(rect) //{{{
		    {
		      setSelectRaw([rect[0] / xscale, rect[1] / yscale, rect[2] / xscale, rect[3] / yscale]);
		      options.onSelect.call(api, unscale(Coords.getFixed()));
		      Selection.enableHandles();
		    }
		    //}}}
		    function setSelectRaw(l) //{{{
		    {
		      Coords.setPressed([l[0], l[1]]);
		      Coords.setCurrent([l[2], l[3]]);
		      Selection.update();
		    }
		    //}}}
		    function tellSelect() //{{{
		    {
		      return unscale(Coords.getFixed());
		    }
		    //}}}
		    function tellScaled() //{{{
		    {
		      return Coords.getFixed();
		    }
		    //}}}
		    function setOptionsNew(opt) //{{{
		    {
		      setOptions(opt);
		      interfaceUpdate();
		    }
		    //}}}
		    function disableCrop() //{{{
		    {
		      options.disabled = true;
		      Selection.disableHandles();
		      Selection.setCursor('default');
		      Tracker.setCursor('default');
		    }
		    //}}}
		    function enableCrop() //{{{
		    {
		      options.disabled = false;
		      interfaceUpdate();
		    }
		    //}}}
		    function cancelCrop() //{{{
		    {
		      Selection.done();
		      Tracker.activateHandlers(null, null);
		    }
		    //}}}
		    function destroy() //{{{
		    {
		      $div.remove();
		      $origimg.show();
		      $origimg.css('visibility','visible');
		      $(obj).removeData('Jcrop');
		    }
		    //}}}
		    function setImage(src, callback) //{{{
		    {
		      Selection.release();
		      disableCrop();
		      var img = new Image();
		      img.onload = function () {
		        var iw = img.width;
		        var ih = img.height;
		        var bw = options.boxWidth;
		        var bh = options.boxHeight;
		        $img.width(iw).height(ih);
		        $img.attr('src', src);
		        $img2.attr('src', src);
		        presize($img, bw, bh);
		        boundx = $img.width();
		        boundy = $img.height();
		        $img2.width(boundx).height(boundy);
		        $trk.width(boundx + (bound * 2)).height(boundy + (bound * 2));
		        $div.width(boundx).height(boundy);
		        Shade.resize(boundx,boundy);
		        enableCrop();
		
		        if (typeof(callback) === 'function') {
		          callback.call(api);
		        }
		      };
		      img.src = src;
		    }
		    //}}}
		    function colorChangeMacro($obj,color,now) {
		      var mycolor = color || options.bgColor;
		      if (options.bgFade && supportsColorFade() && options.fadeTime && !now) {
		        $obj.animate({
		          backgroundColor: mycolor
		        }, {
		          queue: false,
		          duration: options.fadeTime
		        });
		      } else {
		        $obj.css('backgroundColor', mycolor);
		      }
		    }
		    function interfaceUpdate(alt) //{{{
		    // This method tweaks the interface based on options object.
		    // Called when options are changed and at end of initialization.
		    {
		      if (options.allowResize) {
		        if (alt) {
		          Selection.enableOnly();
		        } else {
		          Selection.enableHandles();
		        }
		      } else {
		        Selection.disableHandles();
		      }
		
		      Tracker.setCursor(options.allowSelect ? 'crosshair' : 'default');
		      Selection.setCursor(options.allowMove ? 'move' : 'default');
		
		      if (options.hasOwnProperty('trueSize')) {
		        xscale = options.trueSize[0] / boundx;
		        yscale = options.trueSize[1] / boundy;
		      }
		
		      if (options.hasOwnProperty('setSelect')) {
		        setSelect(options.setSelect);
		        Selection.done();
		        delete(options.setSelect);
		      }
		
		      Shade.refresh();
		
		      if (options.bgColor != bgcolor) {
		        colorChangeMacro(
		          options.shade? Shade.getShades(): $div,
		          options.shade?
		            (options.shadeColor || options.bgColor):
		            options.bgColor
		        );
		        bgcolor = options.bgColor;
		      }
		
		      if (bgopacity != options.bgOpacity) {
		        bgopacity = options.bgOpacity;
		        if (options.shade) Shade.refresh();
		          else Selection.setBgOpacity(bgopacity);
		      }
		
		      xlimit = options.maxSize[0] || 0;
		      ylimit = options.maxSize[1] || 0;
		      xmin = options.minSize[0] || 0;
		      ymin = options.minSize[1] || 0;
		
		      if (options.hasOwnProperty('outerImage')) {
		        $img.attr('src', options.outerImage);
		        delete(options.outerImage);
		      }
		
		      Selection.refresh();
		    }
		    //}}}
		    //}}}
		
		    if (Touch.support) $trk.bind('touchstart.jcrop', Touch.newSelection);
		
		    $hdl_holder.hide();
		    interfaceUpdate(true);
		
		    var api = {
		      setImage: setImage,
		      animateTo: animateTo,
		      setSelect: setSelect,
		      setOptions: setOptionsNew,
		      tellSelect: tellSelect,
		      tellScaled: tellScaled,
		      setClass: setClass,
		
		      disable: disableCrop,
		      enable: enableCrop,
		      cancel: cancelCrop,
		      release: Selection.release,
		      destroy: destroy,
		
		      focus: KeyManager.watchKeys,
		
		      getBounds: function () {
		        return [boundx * xscale, boundy * yscale];
		      },
		      getWidgetSize: function () {
		        return [boundx, boundy];
		      },
		      getScaleFactor: function () {
		        return [xscale, yscale];
		      },
		      getOptions: function() {
		        // careful: internal values are returned
		        return options;
		      },
		
		      ui: {
		        holder: $div,
		        selection: $sel
		      }
		    };
		
		    if (is_msie) $div.bind('selectstart', function () { return false; });
		
		    $origimg.data('Jcrop', api);
		    return api;
		  };
		  $.fn.Jcrop = function (options, callback) //{{{
		  {
		    var api;
		    // Iterate over each object, attach Jcrop
		    this.each(function () {
		      // If we've already attached to this object
		      if ($(this).data('Jcrop')) {
		        // The API can be requested this way (undocumented)
		        if (options === 'api') return $(this).data('Jcrop');
		        // Otherwise, we just reset the options...
		        else $(this).data('Jcrop').setOptions(options);
		      }
		      // If we haven't been attached, preload and attach
		      else {
		        if (this.tagName == 'IMG')
		          $.Jcrop.Loader(this,function(){
		            $(this).css({display:'block',visibility:'hidden'});
		            api = $.Jcrop(this, options);
		            if ($.isFunction(callback)) callback.call(api);
		          });
		        else {
		          $(this).css({display:'block',visibility:'hidden'});
		          api = $.Jcrop(this, options);
		          if ($.isFunction(callback)) callback.call(api);
		        }
		      }
		    });
		
		    // Return "this" so the object is chainable (jQuery-style)
		    return this;
		  };
		  //}}}
		  // $.Jcrop.Loader - basic image loader {{{
		
		  $.Jcrop.Loader = function(imgobj,success,error){
		    var $img = $(imgobj), img = $img[0];
		
		    function completeCheck(){
		      if (img.complete) {
		        $img.unbind('.jcloader');
		        if ($.isFunction(success)) success.call(img);
		      }
		      else window.setTimeout(completeCheck,50);
		    }
		
		    $img
		      .bind('load.jcloader',completeCheck)
		      .bind('error.jcloader',function(e){
		        $img.unbind('.jcloader');
		        if ($.isFunction(error)) error.call(img);
		      });
		
		    if (img.complete && $.isFunction(success)){
		      $img.unbind('.jcloader');
		      success.call(img);
		    }
		  };
		
		  //}}}
		  // Global Defaults {{{
		  $.Jcrop.defaults = {
		
		    // Basic Settings
		    allowSelect: true,
		    allowMove: true,
		    allowResize: true,
		
		    trackDocument: true,
		
		    // Styling Options
		    baseClass: 'jcrop',
		    addClass: null,
		    bgColor: 'black',
		    bgOpacity: 0.6,
		    bgFade: false,
		    borderOpacity: 0.4,
		    handleOpacity: 0.5,
		    handleSize: null,
		
		    aspectRatio: 0,
		    keySupport: true,
		    createHandles: ['n','s','e','w','nw','ne','se','sw'],
		    createDragbars: ['n','s','e','w'],
		    createBorders: ['n','s','e','w'],
		    drawBorders: true,
		    dragEdges: true,
		    fixedSupport: true,
		    touchSupport: null,
		
		    shade: null,
		
		    boxWidth: 0,
		    boxHeight: 0,
		    boundary: 2,
		    fadeTime: 400,
		    animationDelay: 20,
		    swingSpeed: 3,
		
		    minSelect: [0, 0],
		    maxSize: [0, 0],
		    minSize: [0, 0],
		
		    // Callbacks / Event Handlers
		    onChange: function () {},
		    onSelect: function () {},
		    onDblClick: function () {},
		    onRelease: function () {}
		  };
		
		  // }}}
		}(jQuery));
	}
);